{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspect Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all, import `andes` and configure the logger. \n",
    "\n",
    "If logger if not configured, information will not be shown correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import andes\n",
    "\n",
    "andes.main.config_logger()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inspect Model Equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an empty `andes.System` object and call `prepare()` to generate the equations.\n",
    "\n",
    "This operation may take a moment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss = andes.System()\n",
    "ss.prepare()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "odict_keys(['Bus', 'PQ', 'PV', 'Slack', 'Shunt', 'Line', 'Area', 'GENCLS', 'GENROU', 'TG2', 'TGOV1', 'EXDC2', 'Toggler', 'PI2'])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.models.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check model documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check the documentation for the model, print the return of `doc()` for the model instance. \n",
    "\n",
    "For example, the documentation for `GENCLS` can be printed with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model <GENCLS> in Group <SynGen>\n",
      "Parameters\n",
      "\n",
      "Name  |        Description         | Default | Unit |   Type    |   Properties  \n",
      "------+----------------------------+---------+------+-----------+---------------\n",
      " u    | connection status          | 1       | bool | NumParam  |               \n",
      " name | device name                |         |      | DataParam |               \n",
      " bus  | interface bus id           |         |      | IdxParam  | mandatory     \n",
      " gen  | static generator index     |         |      | IdxParam  | mandatory     \n",
      " coi  | center of inertia index    |         |      | IdxParam  |               \n",
      " Sn   | Power rating               | 100     |      | NumParam  |               \n",
      " Vn   | AC voltage rating          | 110     |      | NumParam  |               \n",
      " fn   | rated frequency            | 60      |      | NumParam  |               \n",
      " D    | Damping coefficient        | 0       |      | NumParam  | power         \n",
      " M    | machine start up time (2H) | 6       |      | NumParam  | non_zero,power\n",
      " ra   | armature resistance        | 0       |      | NumParam  | z             \n",
      " xl   | leakage reactance          | 0       |      | NumParam  | z             \n",
      " xq   | q-axis synchronous         | 1.700   |      | NumParam  | z             \n",
      "      | reactance                  |         |      |           |               \n",
      " kp   | active power feedback gain | 0       |      | NumParam  |               \n",
      " kw   | speed feedback gain        | 0       |      | NumParam  |               \n",
      " S10  | first saturation factor    | 0       |      | NumParam  |               \n",
      " S12  | second saturation factor   | 1       |      | NumParam  | non_zero      \n",
      "\n",
      "Variables\n",
      "\n",
      " Name  | Initial Value |       Description       | Unit |   Properties  \n",
      "-------+---------------+-------------------------+------+---------------\n",
      " delta | delta0        |                         |      | v_str         \n",
      " omega | u             |                         |      | v_str         \n",
      " Id    | Id0           |                         |      | v_str         \n",
      " Iq    | Iq0           |                         |      | v_str         \n",
      " vd    | vd0           |                         |      | v_str         \n",
      " vq    | vq0           |                         |      | v_str         \n",
      " tm    | tm0           | mechanical torque       |      | v_str,v_setter\n",
      " te    | p0            | electric torque         |      | v_str,v_setter\n",
      " vf    | vf0           |                         |      | v_str,v_setter\n",
      " psid  | psid0         |                         |      | v_str         \n",
      " psiq  | psiq0         |                         |      | v_str         \n",
      " a     |               | Bus voltage phase angle |      |               \n",
      " v     |               | Bus voltage magnitude   |      |               \n",
      "\n",
      "Equations\n",
      "\n",
      " Name  |         Equation (x'=f or g=0)         |   Type  \n",
      "-------+----------------------------------------+---------\n",
      " delta | u * (2 * pi * fn) * (omega - 1)        | State   \n",
      " omega | (u / M ) * (tm - te - D * (omega - 1)) | State   \n",
      " Id    | + xq * Id - vf+ psid                   | Algeb   \n",
      " Iq    | + xq * Iq+ psiq                        | Algeb   \n",
      " vd    | v * sin(delta - a) - vd                | Algeb   \n",
      " vq    | v * cos(delta - a) - vq                | Algeb   \n",
      " tm    | tm0 - tm                               | Algeb   \n",
      " te    | psid * Iq - psiq * Id - te             | Algeb   \n",
      " vf    | vf0 - vf                               | Algeb   \n",
      " psid  | u * (ra * Iq + vq) - psid              | Algeb   \n",
      " psiq  | u * (ra * Id + vd) + psiq              | Algeb   \n",
      " a     | -u * (vd * Id + vq * Iq)               | ExtAlgeb\n",
      " v     | -u * (vq * Id - vd * Iq)               | ExtAlgeb\n",
      "\n",
      "Services\n",
      "\n",
      "  Name   |                       Equation                        |     Type    \n",
      "---------+-------------------------------------------------------+-------------\n",
      " _V      | v * exp(1j * a)                                       | ConstService\n",
      " _S      | p0 - 1j * q0                                          | ConstService\n",
      " _I      | _S / conj(_V)                                         | ConstService\n",
      " _E      | _V + _I * (ra + 1j * xq)                              | ConstService\n",
      " _deltac | log(_E / abs(_E))                                     | ConstService\n",
      " delta0  | u * im(_deltac)                                       | ConstService\n",
      " vdq     | u * (_V * exp(1j * 0.5 * pi - _deltac))               | ConstService\n",
      " Idq     | u * (_I * exp(1j * 0.5 * pi - _deltac))               | ConstService\n",
      " Id0     | re(Idq)                                               | ConstService\n",
      " Iq0     | im(Idq)                                               | ConstService\n",
      " vd0     | re(vdq)                                               | ConstService\n",
      " vq0     | im(vdq)                                               | ConstService\n",
      " tm0     | u * ((vq0 + ra * Iq0) * Iq0 + (vd0 + ra * Id0) * Id0) | ConstService\n",
      " psid0   | u * (ra * Iq0) + vq0                                  | ConstService\n",
      " psiq0   | -u * (ra * Id0) - vd0                                 | ConstService\n",
      " vf0     | (vq0 + ra * Iq0) + xq * Id0                           | ConstService\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(ss.GENCLS.doc())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretty print of variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model variables symbols are stored in `vars_syms`. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('delta', delta),\n",
       "             ('omega', omega),\n",
       "             ('Id', Id),\n",
       "             ('Iq', Iq),\n",
       "             ('vd', vd),\n",
       "             ('vq', vq),\n",
       "             ('tm', tm),\n",
       "             ('te', te),\n",
       "             ('vf', vf),\n",
       "             ('psid', psid),\n",
       "             ('psiq', psiq),\n",
       "             ('a', a),\n",
       "             ('v', v)])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.vars_syms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Differential variables comes before algebraic variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('delta', State, GENCLS.delta[]),\n",
       "             ('omega', State, GENCLS.omega[])])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('Id', Algeb, GENCLS.Id[]),\n",
       "             ('Iq', Algeb, GENCLS.Iq[]),\n",
       "             ('vd', Algeb, GENCLS.vd[]),\n",
       "             ('vq', Algeb, GENCLS.vq[]),\n",
       "             ('tm', Algeb, GENCLS.tm[]),\n",
       "             ('te', Algeb, GENCLS.te[]),\n",
       "             ('vf', Algeb, GENCLS.vf[]),\n",
       "             ('psid', Algeb, GENCLS.psid[]),\n",
       "             ('psiq', Algeb, GENCLS.psiq[])])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.algebs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Their pretty print can be retrieved from"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\delta\\\\\\omega\\\\I_{d}\\\\I_{q}\\\\V_{d}\\\\V_{q}\\\\\\tau_m\\\\\\tau_e\\\\v_{f}\\\\\\psi_d\\\\\\psi_q\\\\\\theta\\\\V\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[\\delta],\n",
       "[\\omega],\n",
       "[   I_d],\n",
       "[   I_q],\n",
       "[   V_d],\n",
       "[   V_q],\n",
       "[\\tau_m],\n",
       "[\\tau_e],\n",
       "[   v_f],\n",
       "[\\psi_d],\n",
       "[\\psi_q],\n",
       "[\\theta],\n",
       "[     V]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.vars_print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretty print of equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formatted equations are stored in each model. The following attributes are available for equation printing.\n",
    "\n",
    "- f_print\n",
    "- g_print\n",
    "- df_print\n",
    "- dg_print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 \\pi f u \\left(\\omega - 1\\right)\\\\\\frac{u \\left(- D \\left(\\omega - 1\\right) - \\tau_e + \\tau_m\\right)}{M}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[                  2*pi*f*u*(\\omega - 1)],\n",
       "[u*(-D*(\\omega - 1) - \\tau_e + \\tau_m)/M]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.f_print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}I_{d} x_{q} + \\psi_d - v_{f}\\\\I_{q} x_{q} + \\psi_q\\\\V \\sin{\\left(\\delta - \\theta \\right)} - V_{d}\\\\V \\cos{\\left(\\delta - \\theta \\right)} - V_{q}\\\\- \\tau_m + \\tau_{m0}\\\\- I_{d} \\psi_q + I_{q} \\psi_d - \\tau_e\\\\- v_{f} + v_{f0}\\\\- \\psi_d + u \\left(I_{q} r_{a} + V_{q}\\right)\\\\\\psi_q + u \\left(I_{d} r_{a} + V_{d}\\right)\\\\- u \\left(I_{d} V_{d} + I_{q} V_{q}\\right)\\\\- u \\left(I_{d} V_{q} - I_{q} V_{d}\\right)\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[           I_d*x_q + \\psi_d - v_f],\n",
       "[                 I_q*x_q + \\psi_q],\n",
       "[     V*sin(\\delta - \\theta) - V_d],\n",
       "[     V*cos(\\delta - \\theta) - V_q],\n",
       "[              -\\tau_m + \\tau_{m0}],\n",
       "[-I_d*\\psi_q + I_q*\\psi_d - \\tau_e],\n",
       "[                    -v_f + v_{f0}],\n",
       "[      -\\psi_d + u*(I_q*r_a + V_q)],\n",
       "[       \\psi_q + u*(I_d*r_a + V_d)],\n",
       "[           -u*(I_d*V_d + I_q*V_q)],\n",
       "[           -u*(I_d*V_q - I_q*V_d)]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.g_print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{array}{ccccccccccccc}0 & 2 \\pi f u & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & - \\frac{D u}{M} & 0 & 0 & 0 & 0 & \\frac{u}{M} & - \\frac{u}{M} & 0 & 0 & 0 & 0 & 0\\end{array}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 2*pi*f*u, 0, 0, 0, 0,   0,    0, 0, 0, 0, 0, 0],\n",
       "[0,   -D*u/M, 0, 0, 0, 0, u/M, -u/M, 0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.df_print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{array}{ccccccccccccc}0 & 0 & x_{q} & 0 & 0 & 0 & 0 & 0 & -1 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & x_{q} & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\V \\cos{\\left(\\delta - \\theta \\right)} & 0 & 0 & 0 & -1 & 0 & 0 & 0 & 0 & 0 & 0 & - V \\cos{\\left(\\delta - \\theta \\right)} & \\sin{\\left(\\delta - \\theta \\right)}\\\\- V \\sin{\\left(\\delta - \\theta \\right)} & 0 & 0 & 0 & 0 & -1 & 0 & 0 & 0 & 0 & 0 & V \\sin{\\left(\\delta - \\theta \\right)} & \\cos{\\left(\\delta - \\theta \\right)}\\\\0 & 0 & 0 & 0 & 0 & 0 & -1 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & - \\psi_q & \\psi_d & 0 & 0 & 0 & -1 & 0 & I_{q} & - I_{d} & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & r_{a} u & 0 & u & 0 & 0 & 0 & -1 & 0 & 0 & 0\\\\0 & 0 & r_{a} u & 0 & u & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & - V_{d} u & - V_{q} u & - I_{d} u & - I_{q} u & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & - V_{q} u & V_{d} u & I_{q} u & - I_{d} u & 0 & 0 & 0 & 0 & 0 & 0 & 0\\end{array}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[                      0, 0,     x_q,      0,      0,      0,  0,  0, -1,   1,    0,                       0,                    0],\n",
       "[                      0, 0,       0,    x_q,      0,      0,  0,  0,  0,   0,    1,                       0,                    0],\n",
       "[ V*cos(\\delta - \\theta), 0,       0,      0,     -1,      0,  0,  0,  0,   0,    0, -V*cos(\\delta - \\theta), sin(\\delta - \\theta)],\n",
       "[-V*sin(\\delta - \\theta), 0,       0,      0,      0,     -1,  0,  0,  0,   0,    0,  V*sin(\\delta - \\theta), cos(\\delta - \\theta)],\n",
       "[                      0, 0,       0,      0,      0,      0, -1,  0,  0,   0,    0,                       0,                    0],\n",
       "[                      0, 0, -\\psi_q, \\psi_d,      0,      0,  0, -1,  0, I_q, -I_d,                       0,                    0],\n",
       "[                      0, 0,       0,      0,      0,      0,  0,  0, -1,   0,    0,                       0,                    0],\n",
       "[                      0, 0,       0,  r_a*u,      0,      u,  0,  0,  0,  -1,    0,                       0,                    0],\n",
       "[                      0, 0,   r_a*u,      0,      u,      0,  0,  0,  0,   0,    1,                       0,                    0],\n",
       "[                      0, 0,  -V_d*u, -V_q*u, -I_d*u, -I_q*u,  0,  0,  0,   0,    0,                       0,                    0],\n",
       "[                      0, 0,  -V_q*u,  V_d*u,  I_q*u, -I_d*u,  0,  0,  0,   0,    0,                       0,                    0]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.dg_print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretty print of services"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list of services is in `services`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('_V', <andes.core.service.ConstService at 0x11344e050>),\n",
       "             ('_S', <andes.core.service.ConstService at 0x11344e0d0>),\n",
       "             ('_I', <andes.core.service.ConstService at 0x11344e110>),\n",
       "             ('_E', <andes.core.service.ConstService at 0x11344e150>),\n",
       "             ('_deltac', <andes.core.service.ConstService at 0x11344e190>),\n",
       "             ('delta0', <andes.core.service.ConstService at 0x11344e1d0>),\n",
       "             ('vdq', <andes.core.service.ConstService at 0x11344e090>),\n",
       "             ('Idq', <andes.core.service.ConstService at 0x11344e210>),\n",
       "             ('Id0', <andes.core.service.ConstService at 0x11344e250>),\n",
       "             ('Iq0', <andes.core.service.ConstService at 0x11344e290>),\n",
       "             ('vd0', <andes.core.service.ConstService at 0x11344e2d0>),\n",
       "             ('vq0', <andes.core.service.ConstService at 0x11344e310>),\n",
       "             ('tm0', <andes.core.service.ConstService at 0x11344e350>),\n",
       "             ('psid0', <andes.core.service.ConstService at 0x11344e390>),\n",
       "             ('psiq0', <andes.core.service.ConstService at 0x11344e3d0>),\n",
       "             ('vf0', <andes.core.service.ConstService at 0x11344e410>)])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.services"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Service equations are stored in `s_print`. For example, services of `GENCLS` is in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}V e^{i \\theta}\\\\P_{0} - i Q_{0}\\\\\\frac{S}{\\operatorname{conj}{\\left(V_{c} \\right)}}\\\\I_{c} \\left(r_{a} + i x_{q}\\right) + V_{c}\\\\\\log{\\left(\\frac{E}{\\operatorname{abs}{\\left(E \\right)}} \\right)}\\\\u \\operatorname{im}{\\left(\\delta_c\\right)}\\\\V_{c} u e^{- \\delta_c + 0.5 i \\pi}\\\\I_{c} u e^{- \\delta_c + 0.5 i \\pi}\\\\\\operatorname{re}{\\left(I_{dq}\\right)}\\\\\\operatorname{im}{\\left(I_{dq}\\right)}\\\\\\operatorname{re}{\\left(V_{dq}\\right)}\\\\\\operatorname{im}{\\left(V_{dq}\\right)}\\\\u \\left(I_{d0} \\left(I_{d0} r_{a} + V_{d0}\\right) + I_{q0} \\left(I_{q0} r_{a} + V_{q0}\\right)\\right)\\\\I_{q0} r_{a} u + V_{q0}\\\\- I_{d0} r_{a} u - V_{d0}\\\\I_{d0} x_{q} + I_{q0} r_{a} + V_{q0}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[                                                V*exp(I*\\theta)],\n",
       "[                                                    P_0 - I*Q_0],\n",
       "[                                                    S/conj(V_c)],\n",
       "[                                        I_c*(r_a + I*x_q) + V_c],\n",
       "[                                                  log(E/abs(E))],\n",
       "[                                                 u*im(\\delta_c)],\n",
       "[                                V_c*u*exp(-\\delta_c + 0.5*I*pi)],\n",
       "[                                I_c*u*exp(-\\delta_c + 0.5*I*pi)],\n",
       "[                                                     re(I_{dq})],\n",
       "[                                                     im(I_{dq})],\n",
       "[                                                     re(V_{dq})],\n",
       "[                                                     im(V_{dq})],\n",
       "[u*(I_{d0}*(I_{d0}*r_a + V_{d0}) + I_{q0}*(I_{q0}*r_a + V_{q0}))],\n",
       "[                                          I_{q0}*r_a*u + V_{q0}],\n",
       "[                                         -I_{d0}*r_a*u - V_{d0}],\n",
       "[                               I_{d0}*x_q + I_{q0}*r_a + V_{q0}]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss.GENCLS.s_print"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
